package com.framework.test.context;

import java.util.concurrent.ConcurrentHashMap;
import java.util.Map;

/**
 * 全局数据存储上下文类
 * 提供线程安全的键值对存储，支持全局数据共享
 * 使用单例模式确保全局唯一性
 */
public class GlobalContext {
    
    private static final GlobalContext INSTANCE = new GlobalContext();
    private final Map<String, Object> contextData;
    
    /**
     * 私有构造函数，防止外部实例化
     */
    private GlobalContext() {
        this.contextData = new ConcurrentHashMap<>();
    }
    
    /**
     * 获取全局上下文实例
     * 
     * @return GlobalContext实例
     */
    public static GlobalContext getInstance() {
        return INSTANCE;
    }
    
    /**
     * 存储键值对数据
     * 
     * @param key 键
     * @param value 值
     */
    public void put(String key, Object value) {
        if (key != null) {
            contextData.put(key, value);
        }
    }
    
    /**
     * 获取指定键的值
     * 
     * @param key 键
     * @return 对应的值，如果不存在则返回null
     */
    public Object get(String key) {
        return contextData.get(key);
    }
    
    /**
     * 获取指定键的字符串值
     * 
     * @param key 键
     * @return 对应的字符串值，如果不存在或不是字符串则返回null
     */
    public String getString(String key) {
        Object value = contextData.get(key);
        return value instanceof String ? (String) value : null;
    }
    
    /**
     * 获取指定键的字符串值，如果不存在则返回默认值
     * 
     * @param key 键
     * @param defaultValue 默认值
     * @return 对应的字符串值或默认值
     */
    public String getString(String key, String defaultValue) {
        String value = getString(key);
        return value != null ? value : defaultValue;
    }
    
    /**
     * 检查是否包含指定的键
     * 
     * @param key 键
     * @return 如果包含则返回true，否则返回false
     */
    public boolean containsKey(String key) {
        return contextData.containsKey(key);
    }
    
    /**
     * 移除指定键的数据
     * 
     * @param key 键
     * @return 被移除的值，如果不存在则返回null
     */
    public Object remove(String key) {
        return contextData.remove(key);
    }
    
    /**
     * 清空所有数据
     */
    public void clear() {
        contextData.clear();
    }
    
    /**
     * 获取所有键的集合
     * 
     * @return 键的集合
     */
    public java.util.Set<String> keySet() {
        return contextData.keySet();
    }
    
    /**
     * 获取上下文数据的大小
     * 
     * @return 数据项数量
     */
    public int size() {
        return contextData.size();
    }
    
    /**
     * 检查上下文是否为空
     * 
     * @return 如果为空则返回true，否则返回false
     */
    public boolean isEmpty() {
        return contextData.isEmpty();
    }
    
    /**
     * 获取所有数据的副本
     * 
     * @return 包含所有数据的Map副本
     */
    public Map<String, Object> getAllData() {
        return new ConcurrentHashMap<>(contextData);
    }
    
    /**
     * 批量设置数据
     * 
     * @param data 要设置的数据Map
     */
    public void putAll(Map<String, Object> data) {
        if (data != null) {
            contextData.putAll(data);
        }
    }
    
    /**
     * 替换字符串中的占位符
     * 占位符格式：${key}
     * 
     * @param template 包含占位符的模板字符串
     * @return 替换后的字符串
     */
    public String replacePlaceholders(String template) {
        if (template == null || template.trim().isEmpty()) {
            return template;
        }
        
        String result = template;
        
        // 使用正则表达式查找所有 ${key} 格式的占位符
        java.util.regex.Pattern pattern = java.util.regex.Pattern.compile("\\$\\{([^}]+)\\}");
        java.util.regex.Matcher matcher = pattern.matcher(result);
        
        StringBuffer sb = new StringBuffer();
        while (matcher.find()) {
            String key = matcher.group(1);
            Object value = contextData.get(key);
            String replacement = value != null ? value.toString() : "";
            matcher.appendReplacement(sb, java.util.regex.Matcher.quoteReplacement(replacement));
        }
        matcher.appendTail(sb);
        
        return sb.toString();
    }
    
    @Override
    public String toString() {
        return "GlobalContext{" +
                "size=" + contextData.size() +
                ", data=" + contextData +
                '}';
    }
}